home *** CD-ROM | disk | FTP | other *** search
/ PC-SIG: World of Games / PC-SIG World of Games (CDRM1080710) (1993).iso / ENT / DISK0946.ZIP / BASKBALL.C < prev    next >
Text File  |  1987-05-03  |  37KB  |  1,322 lines
  1. #include <stdlib.h>
  2. #include <stdio.h>
  3. #include <math.h>
  4.  
  5. /*****************
  6.  *   constants   *
  7.  *****************/
  8.  
  9. #define SAVE_FMT         "%10s %d %d %d %d %d %d %d %d %d %d\n"
  10. #define TEAM_SAVE_FMT    "%10s %d %d %d\n"
  11. #define ROSTER_FMT       "%10s\n"
  12.  
  13. #define TRUE  1                  /*   logical constants                */
  14. #define FALSE 0
  15.  
  16. #define GAMETIME 60              /*   initial game clock setting       */
  17. #define SEC      .15             /*   game clock decrement             */
  18. #define LDELAY   15000           /*   long time delay setting          */
  19. #define SDELAY   0               /*   short delay setting              */
  20.  
  21. #define DRIVE 0                  /*   player action codes              */
  22. #define PASS  1
  23. #define SHOOT 2
  24.  
  25. #define DEF_FOUL    0            /*   result codes for player actions  */
  26. #define FG2         1
  27. #define FG3         2
  28. #define TURNOVER    3
  29. #define NO_CHANGE   4
  30.  
  31. /*************************
  32.  *   System structures   *
  33.  *************************/
  34.  
  35. typedef struct players {
  36.  
  37.    char name[10];         /*   player's name                    */
  38.    int num;               /*   player's number                  */
  39.    int perc_fg2;          /*   player skills : 2 pt FG%         */
  40.    int perc_fg3;          /*                   3 pt FG%         */
  41.    int perc_ft;           /*                   FT%              */
  42.    int perc_reb;          /*                   rebound %        */
  43.    int perc_blk;          /*                   block shot %     */
  44.    int perc_steal;        /*                   steal ball %     */
  45.    int perc_shoot;        /*   player actions: shoot the ball % */
  46.    int perc_pass;         /*                   pass the ball %  */
  47.    int perc_drive;        /*                   drive to basket% */
  48.    int fg2_made;          /*   game stats : 2 pt FGs made       */
  49.    int fg2_att;           /*                2 pt FGs attempted  */
  50.    int fg3_made;          /*                3 pt FGs made       */
  51.    int fg3_att;           /*                3 pt FGs attempted  */
  52.    int ft_made;           /*                FTs made            */
  53.    int ft_att;            /*                FTs attempted       */
  54.    int num_reb;           /*                number of rebounds  */
  55.    int num_blk;           /*                number of blocks    */
  56.    int num_steal;         /*                number of steals    */
  57.  
  58. } PLAYER, *PLAYER_PTR;
  59.  
  60. typedef struct teams {
  61.  
  62.    char team_name[10];        /*   name of team           */
  63.    struct players *(pl[5]);   /*   players on that team   */
  64.    int score;                 /*   current score          */
  65.    int foul;
  66.    int win;                   /*   number of wins         */
  67.    int loss;                  /*   number of losses       */
  68.    int tie;                   /*   number of ties         */
  69.  
  70. } TEAM, *TEAM_PTR;
  71.  
  72. /************************
  73.  *   Global variables   *
  74.  ************************/
  75.  
  76. int ball = 0;
  77. TEAM_PTR team_a = NULL, team_b = NULL;
  78. float time;
  79. int delay = 0;
  80. int back_court;                    /*   to force at least one pass   */
  81. int shooting;                      /*   in the act of shooting ?     */
  82.  
  83. /********************
  84.  *   main program   *
  85.  ********************/
  86.  
  87. main()
  88.  
  89. {
  90.    char dummy[1];
  91.    int act = 0, seed = 0, ans = 0;
  92.    int i,games = 0;
  93.    int menu(), opt = 0;
  94.    TEAM_PTR off, def;
  95.    TEAM_PTR maketeam(), load_team(), jump_ball(), proc_action();
  96.  
  97.    printf("Enter RANDOM number seed = ");
  98.    scanf("%d",&seed);
  99.    srand(seed);
  100.  
  101.    while (opt != 3) {
  102.       opt = menu();               /*   show menu & get option   */
  103.       switch (opt) {
  104.          case 0 :
  105.             exit(0);
  106.             break;
  107.          case 1 :
  108.             new_player();
  109.             break;
  110.          case 2 :
  111.             new_team();
  112.             break;
  113.          case 3 :
  114.             team_a = load_team();
  115.             team_b = load_team();
  116.             if ((team_a != NULL) && (team_b != NULL)) {
  117.                show_team(team_a);
  118.                show_team(team_b);
  119.                printf("\nPress <enter> to continue");
  120.                scanf("%s",dummy);
  121.                }
  122.             else
  123.                opt = 0;
  124.             break;
  125.          case 4 :
  126.             team_a = load_team();
  127.             if (team_a != NULL) {
  128.                show_team(team_a);
  129.                printf("\nPress <enter> to continue");
  130.                scanf("%s",dummy);
  131.                }
  132.             break;
  133.          case 5 :
  134.             list_players();
  135.             printf("\nPress <enter> to continue");
  136.             scanf("%s",dummy);
  137.             break;
  138.          }
  139.       }
  140.  
  141.    printf("\nDo you want a Long time delay ? (0 - NO, 1 - YES) ");
  142.    scanf("%d",&ans);
  143.    if (ans)
  144.       delay = LDELAY;
  145.    else
  146.       delay = SDELAY;
  147.    printf("Enter number of games to be played : ");
  148.    scanf("%d",&games);
  149.  
  150.    for (i = 0;i < games; i++) {
  151.  
  152.       time = GAMETIME;
  153.       team_a->score = 0;
  154.       team_b->score = 0;
  155.       team_a->foul = 0;
  156.       team_b->foul = 0;
  157.       printf("\n\nGame time !!!\n\n");
  158.       printf("The %s vs. the %s\n",team_a->team_name,team_b->team_name);
  159.       
  160.       off = jump_ball(team_a,team_b);
  161.       def = (off == team_a) ? team_b : team_a ;
  162.       
  163.       while (time > 0) {
  164.          shooting = FALSE;
  165.          act = action(off);                            /*   determine action   */
  166.          off = proc_action(off,def,act);               /*   do action          */
  167.          def = (off == team_a) ? team_b : team_a ;
  168.          time -= SEC;                                  /*   decrement time     */
  169.          }
  170.       
  171.       printf("\nBZZZZZZZZZZZZ...the game is over !!!\n");
  172.       
  173.       if (team_a->score > team_b->score) {
  174.          printf("\n*** The %s win it !!!\n",team_a->team_name);
  175.          (team_a->win)++;
  176.          (team_b->loss)++;
  177.          }
  178.       else if (team_b->score > team_a->score) {
  179.          printf("\n*** The %s win it !!!\n",team_b->team_name);
  180.          (team_b->win)++;
  181.          (team_a->loss)++;
  182.          }
  183.       else {
  184.          printf("*** Its a TIE !!!\n");
  185.          (team_a->tie)++;
  186.          (team_b->tie)++;
  187.          }
  188.       
  189.       printf("\n*** Final Score : %s %d   %s %d\n",team_a->team_name,team_a->score,team_b->team_name,team_b->score);
  190.       
  191.       show_game(team_a);
  192.       show_game(team_b);
  193.  
  194.       }       /*   next    i   */
  195.  
  196.    printf("Press <enter> to continue");
  197.    scanf("%s",dummy);
  198.  
  199.    printf("\n*** Final Statistics ***\n");
  200.    show_game(team_a);
  201.    show_game(team_b);
  202.  
  203.    printf("\nDo you wish to save the team records ? ");
  204.    scanf("%d",&ans);
  205.    if (ans) {
  206.       save_team(team_a);
  207.       save_team(team_b);
  208.       }
  209.  
  210. }   /*   end of main program   */
  211.  
  212. /*****************
  213.  *   main menu   *
  214.  *****************/
  215.  
  216. int menu()
  217.  
  218. {
  219.    int ret_val = 0;
  220.  
  221.    printf("\n\n\n\n\n");
  222.    printf("                   COMPUTER BASKETBALL 2.0\n\n");
  223.    printf("                       0) EXIT\n");
  224.    printf("                       1) Create new player\n");
  225.    printf("                       2) Create new team\n");
  226.    printf("                       3) Pick teams/play game\n");
  227.    printf("                       4) Show a team\n");
  228.    printf("                       5) List players\n");
  229.    printf("\n                       Select : ");
  230.    scanf("%d",&ret_val);
  231.  
  232.    return(ret_val);
  233. }
  234.  
  235. /******************
  236.  *   new player   *
  237.  ******************/
  238.  
  239. new_player()
  240.  
  241. {
  242.    char *calloc();
  243.    int ans = 0;
  244.    PLAYER_PTR rand_player(), enter_player(), pp;
  245.  
  246.    printf("\nDo you want a randomly generated player (1 - yes/0 - no) ? ");
  247.    scanf("%d",&ans);
  248.    if (ans)
  249.       pp = rand_player();
  250.    else
  251.       pp = enter_player();
  252.    show_player(pp);
  253.  
  254.    printf("\nDo you wish to save this player (1 - yes/0 - no) ? ");
  255.    scanf("%d",&ans);
  256.    if (ans)
  257.       save_player(pp);
  258. }
  259.  
  260. /*********************
  261.  *   random player   *
  262.  *********************/
  263.  
  264. PLAYER_PTR rand_player()
  265.  
  266. {
  267.    int i;
  268.    PLAYER_PTR pp;
  269.  
  270.    pp = (PLAYER_PTR) calloc(1,sizeof(PLAYER));
  271.  
  272.    printf("\nEnter name of player : ");
  273.    scanf("%s",pp->name);
  274.    printf("Enter number of player : ");
  275.    scanf("%d",&(pp->num));
  276.  
  277.    pp->perc_fg3 = random(0,50);
  278.    pp->perc_ft = random(60,95);
  279.    pp->perc_fg2 = random(40,70);
  280.    pp->perc_reb = random(5,50);
  281.    pp->perc_steal = random(5,50);
  282.    pp->perc_blk = (int) (.25 * (pp->perc_reb));
  283.    pp->perc_shoot = (int) (pp->perc_fg2);
  284.    pp->perc_drive = (int) (pp->perc_reb / 2);
  285.    pp->perc_pass = (100 - (pp->perc_shoot) - (pp->perc_drive));
  286.  
  287.    return(pp);
  288. }
  289.  
  290. /**********************
  291.  *   enter a player   *
  292.  **********************/
  293.  
  294. PLAYER_PTR enter_player()
  295.  
  296. {
  297.    PLAYER_PTR pp;
  298.  
  299.    pp = (PLAYER_PTR) calloc(1,sizeof(PLAYER));
  300.  
  301.    printf("\nEnter name of player : ");
  302.    scanf("%s",pp->name);
  303.    printf("Enter number of player : ");
  304.    scanf("%d",&(pp->num));
  305.    printf("Enter 2 point FG %% : ");
  306.    scanf("%d",&(pp->perc_fg2));
  307.    printf("Enter 3 point FG %% : ");
  308.    scanf("%d",&(pp->perc_fg3));
  309.    printf("Enter free throw %% : ");
  310.    scanf("%d",&(pp->perc_ft));
  311.    printf("Enter rebounding %% (5 - 50) : ");
  312.    scanf("%d",&(pp->perc_reb));
  313.    printf("Enter ball stealing %% (5 - 50) : ");
  314.    scanf("%d",&(pp->perc_steal));
  315.    pp->perc_blk = (int) (.25 * (pp->perc_reb));
  316.    pp->perc_shoot = (int) (pp->perc_fg2);
  317.    pp->perc_drive = (int) (pp->perc_reb / 2);
  318.    pp->perc_pass = (100 - (pp->perc_shoot) - (pp->perc_drive));
  319.  
  320.    return(pp);
  321. }
  322.  
  323. /*******************
  324.  *   show player   *
  325.  *******************/
  326.  
  327. show_player(pp)
  328.  
  329. PLAYER_PTR pp;
  330.  
  331. {
  332.    printf("\nName : %s     Number : %d\n",pp->name,pp->num);
  333.    printf("   2 pt FG%% : %d\n",pp->perc_fg2);
  334.    printf("   3 pt FG%% : %d\n",pp->perc_fg3);
  335.    printf("   FT %%     : %d\n",pp->perc_ft);
  336.    printf("   Reb %%    : %d\n",pp->perc_reb);
  337.    printf("   Steal %%  : %d\n",pp->perc_steal);
  338.    printf("   Block %%  : %d\n",pp->perc_blk);
  339.    printf("   Player action - Shoot %% : %d\n",pp->perc_shoot);
  340.    printf("                   Drive %% : %d\n",pp->perc_drive);
  341.    printf("                   Pass %%  : %d\n",pp->perc_pass);
  342. }
  343.  
  344. /*********************
  345.  *   save a player   *
  346.  *********************/
  347.  
  348. save_player(pp)
  349.  
  350. PLAYER_PTR pp;
  351.  
  352. {
  353.    int ans;
  354.    FILE *fopen(), *fp;
  355.  
  356.    ans = 0;
  357.    if ((fp = fopen(pp->name,"r")) != NULL) {
  358.       printf("\nPlayer already exists, Overwrite (1 - yes/0 - no) ? ");
  359.       scanf("%d",&ans);
  360.       }
  361.    if ((fp == NULL) || (ans)) {
  362.       printf("\nSaving...\n");
  363.       fclose(fp);
  364.       fp = fopen(pp->name,"w");
  365.       fprintf(fp,SAVE_FMT,pp->name,pp->num,pp->perc_fg2,pp->perc_fg3,
  366.                           pp->perc_ft,pp->perc_reb,pp->perc_steal,
  367.                           pp->perc_blk,pp->perc_shoot,pp->perc_drive,
  368.                           pp->perc_pass);
  369.       printf("\nDone...\n");
  370.       }
  371.    else
  372.       printf("\nPlayer NOT saved...\n");
  373.    fclose(fp);
  374. }
  375.  
  376. /*********************
  377.  *   load a player   *
  378.  *********************/
  379.  
  380. PLAYER_PTR load_player()
  381.  
  382. {
  383.    PLAYER_PTR pp = NULL;
  384.    char name[10], *calloc();
  385.    FILE *fopen(), *fp;
  386.  
  387.    printf("\nEnter name of player to load : ");
  388.    scanf("%s",name);
  389.    if ((fp = fopen(name,"r")) == NULL)
  390.       printf("\nPlayer does NOT exist...\n");
  391.    else {
  392.       printf("\nLoading...\n");
  393.       pp = (PLAYER_PTR) calloc(1,sizeof(PLAYER));
  394.       fscanf(fp,SAVE_FMT,pp->name,&(pp->num),&(pp->perc_fg2),&(pp->perc_fg3),
  395.                          &(pp->perc_ft),&(pp->perc_reb),&(pp->perc_steal),
  396.                          &(pp->perc_blk),&(pp->perc_shoot),&(pp->perc_drive),
  397.                          &(pp->perc_pass));
  398.       printf("\nDone...\n");  
  399.       }                       
  400.    fclose(fp);                
  401.                               
  402.    return(pp);                
  403. }                             
  404.  
  405. /***********************
  406.  *   list of players   *
  407.  ***********************/
  408.  
  409. list_players()
  410.  
  411. {
  412.    FILE *fopen(), *fp, *rp;
  413.    PLAYER_PTR pp;
  414.    char name[10];
  415.  
  416.    pp = (PLAYER_PTR) calloc(1,sizeof(PLAYER));
  417.    printf("\nName        #    2 pt FG%%   3 pt FG%%   FT%%   Reb%%   Blk%%   Steal%%\n");
  418.    printf("-----------------------------------------------------------------------\n");
  419.    if ((rp = fopen("ROSTER.DIR","r")) == NULL)
  420.       printf("Unable to open file ROSTER.DIR\n");
  421.    else {
  422.       while ((fscanf(rp,ROSTER_FMT,name)) != EOF) {
  423.          if ((fp = fopen(name,"r")) == NULL)
  424.             printf("\nPlayer : %10s does NOT exist...\n",name);
  425.          else {
  426.             fscanf(fp,SAVE_FMT,pp->name,&(pp->num),&(pp->perc_fg2),&(pp->perc_fg3),
  427.                                &(pp->perc_ft),&(pp->perc_reb),&(pp->perc_steal),
  428.                                &(pp->perc_blk),&(pp->perc_shoot),&(pp->perc_drive),
  429.                                &(pp->perc_pass));
  430.             fclose(fp);
  431.             printf("%10s  %2d ",pp->name,pp->num);
  432.             printf("    %2d %%",pp->perc_fg2);
  433.             printf("       %2d %%",pp->perc_fg3);
  434.             printf("     %2d %%",pp->perc_ft);
  435.             printf("  %2d %%",pp->perc_reb);
  436.             printf("   %2d %%",pp->perc_blk);
  437.             printf("     %2d %%\n",pp->perc_steal);
  438.             }
  439.          }
  440.       fclose(rp);
  441.       }
  442. }
  443.                               
  444. /****************             
  445.  *   new team   *             
  446.  ****************/
  447.  
  448. new_team()
  449.  
  450. {
  451.    int i, ans = 0;
  452.    char *calloc(), name[10];
  453.    PLAYER_PTR load_player();
  454.    TEAM_PTR maketeam(), tp = NULL;
  455.  
  456.    printf("\nDo you wish a randomly created team (1 - yes/0 - no) ? ");
  457.    scanf("%d",&ans);
  458.    if (ans) {
  459.       printf("\nGenerating a new team...\n");
  460.       tp = maketeam();
  461.       }
  462.    else {
  463.       printf("\nLoading players to form a team :\n ");
  464.       tp = (TEAM_PTR) calloc(1,sizeof(TEAM));
  465.       printf("\nEnter team name : ");
  466.       scanf("%s",tp->team_name);
  467.       for (i = 0;i < 5; i++) {
  468.          while ((tp->pl[i]) == NULL) {
  469.             (tp->pl[i]) = load_player();
  470.             show_player(tp->pl[i]);
  471.             }
  472.          }         /*   next i   */
  473.       }            /*   endif    */
  474.    show_team(tp);
  475.    printf("\nDo you wish to save this team (1 - yes/0 - no) ? ");
  476.    scanf("%d",&ans);
  477.    if (ans)
  478.       save_team(tp);
  479. }
  480.  
  481. /*****************
  482.  *   load team   *
  483.  *****************/
  484.  
  485. TEAM_PTR load_team()
  486.  
  487. {
  488.    char name[10], *calloc();
  489.    int i;
  490.    PLAYER_PTR pp = NULL;
  491.    TEAM_PTR tp = NULL;
  492.    FILE *fopen(), *fp;
  493.  
  494.    printf("\nEnter name of team to load : ");
  495.    scanf("%s",name);
  496.    if ((fp = fopen(name,"r")) == NULL)
  497.       printf("\nTeam does NOT exist\n");
  498.    else {
  499.       printf("\nLoading...\n");
  500.       tp = (TEAM_PTR) calloc(1,sizeof(TEAM));
  501.       fscanf(fp,TEAM_SAVE_FMT,tp->team_name,&(tp->win),&(tp->loss),&(tp->tie));
  502.       for (i = 0;i < 5; i++) {
  503.          pp = (PLAYER_PTR) calloc(1,sizeof(PLAYER));
  504.          fscanf(fp,SAVE_FMT,pp->name,&(pp->num),&(pp->perc_fg2),&(pp->perc_fg3),
  505.                             &(pp->perc_ft),&(pp->perc_reb),&(pp->perc_steal),
  506.                             &(pp->perc_blk),&(pp->perc_shoot),&(pp->perc_drive),
  507.                             &(pp->perc_pass));
  508.          (tp->pl[i]) = pp;
  509.          }
  510.       printf("\nDone...\n");
  511.       }
  512.    fclose(fp);
  513.  
  514.    return(tp);
  515. }
  516.  
  517. /*****************
  518.  *   save team   *
  519.  *****************/
  520.  
  521. save_team(tp)
  522.  
  523. TEAM_PTR tp;
  524.  
  525. {
  526.    int i, ans = 0;
  527.    PLAYER_PTR pp;
  528.    FILE *fopen(), *fp;
  529.  
  530.    if ((fp = fopen(tp->team_name,"r")) != NULL) {
  531.       printf("\nTeam already exists, Overwrite (1 - yes/0 - no) ? ");
  532.       scanf("%d",&ans);
  533.       }
  534.    if ((fp == NULL) || (ans)) {
  535.       printf("\nSaving...\n");
  536.       fclose(fp);
  537.       fp = fopen(tp->team_name,"w");
  538.       fprintf(fp,TEAM_SAVE_FMT,tp->team_name,tp->win,tp->loss,tp->tie);
  539.       for (i = 0;i < 5; i++) {
  540.          pp = tp->pl[i];
  541.          fprintf(fp,SAVE_FMT,pp->name,pp->num,pp->perc_fg2,pp->perc_fg3,
  542.                              pp->perc_ft,pp->perc_reb,pp->perc_steal,
  543.                              pp->perc_blk,pp->perc_shoot,pp->perc_drive,
  544.                              pp->perc_pass);
  545.          }
  546.       printf("\nDone...\n");
  547.       }
  548.    else
  549.       printf("\nTeam NOT saved...\n");
  550.    fclose(fp);
  551. }
  552.  
  553. /*******************
  554.  *   make a team   *
  555.  *******************/
  556.  
  557. TEAM_PTR maketeam()
  558.  
  559. {
  560.    int i;
  561.    char *calloc();
  562.    TEAM_PTR tp;
  563.    PLAYER_PTR pp, rand_player();
  564.  
  565.    tp = (TEAM_PTR) calloc(1,sizeof(TEAM));
  566.  
  567.    printf("\nEnter Team name : ");
  568.    scanf("%s",tp->team_name);
  569.    for (i = 0; i < 5; i++) {
  570.       pp = (PLAYER_PTR) calloc(1,sizeof(PLAYER));
  571.  
  572.       tp->pl[i] = rand_player();
  573.       }
  574.    return(tp);
  575. }
  576.  
  577. /*****************
  578.  *   show team   *
  579.  *****************/
  580.  
  581. show_team(tp)
  582.  
  583. TEAM_PTR tp;
  584.  
  585. {
  586.    int i;
  587.    PLAYER_PTR pp;
  588.  
  589.    printf("\n*** Team : %s ***   Record : %2d - %2d - %2d\n",tp->team_name,tp->win,tp->loss,tp->tie);
  590.    printf("\nName        #  Posi     2 pt FG%%   3 pt FG%%   FT%%   Reb%%   Blk%%   Steal%%\n");
  591.    for (i = 0;i < 5; i++) {
  592.       pp = tp->pl[i];
  593.       printf("%10s  %2d ",pp->name,pp->num);
  594.       if ((i == 0) || (i == 1))
  595.          printf("guard  ");
  596.       else if ((i == 2) || (i == 3))
  597.          printf("forward");
  598.       else if (i == 4)
  599.          printf("center ");
  600.       printf("    %2d %%",pp->perc_fg2);
  601.       printf("       %2d %%",pp->perc_fg3);
  602.       printf("     %2d %%",pp->perc_ft);
  603.       printf("  %2d %%",pp->perc_reb);
  604.       printf("   %2d %%",pp->perc_blk);
  605.       printf("     %2d %%\n",pp->perc_steal);
  606.       }
  607. }
  608.  
  609. /***********************
  610.  *   show game stats   *
  611.  ***********************/
  612.  
  613. show_game(tp)
  614.  
  615. TEAM_PTR tp;
  616.  
  617. {
  618.    int i;
  619.    float att2 = 0, made2 = 0, att3 = 0, made3 = 0, attft = 0, madeft = 0, rebs = 0, blks = 0, steals = 0;
  620.    float fg2perc, fg3perc, ftperc;
  621.    PLAYER_PTR pp;
  622.  
  623.    printf("\n*** Team : %s ***   Record : %2d - %2d - %2d\n",tp->team_name,tp->win,tp->loss,tp->tie);
  624.    printf("                           2 pt.      3 pt.       FT\n");
  625.    printf("Name        #  Posi     made  att  made  att  made  att  Rebs  Blks  Stls\n");
  626.    for (i = 0;i < 5; i++) {
  627.       pp = tp->pl[i];
  628.       printf("%10s  %2d ",pp->name,pp->num);
  629.       if ((i == 0) || (i == 1))
  630.          printf("guard  ");
  631.       else if ((i == 2) || (i == 3))
  632.          printf("forward");
  633.       else if (i == 4)
  634.          printf("center ");
  635.       printf("   %2d",pp->fg2_made);
  636.       printf("   %2d",pp->fg2_att);
  637.       printf("    %2d",pp->fg3_made);
  638.       printf("   %2d",pp->fg3_att);
  639.       printf("    %2d",pp->ft_made);
  640.       printf("   %2d",pp->ft_att);
  641.       printf("    %2d",pp->num_reb);
  642.       printf("    %2d",pp->num_blk);
  643.       printf("    %2d\n",pp->num_steal);
  644.  
  645.       att2   += pp->fg2_att;                /*   keep track of totals   */
  646.       made2  += pp->fg2_made;
  647.       att3   += pp->fg3_att;
  648.       made3  += pp->fg3_made;
  649.       attft  += pp->ft_att;
  650.       madeft += pp->ft_made;
  651.       rebs   += pp->num_reb;
  652.       blks   += pp->num_blk;
  653.       steals += pp->num_steal;
  654.       }
  655.    if (att2 != 0)
  656.       fg2perc = made2 / att2;                  /*   calc. shot percentages   */
  657.    else
  658.       fg2perc = 0;
  659.    if (att3 != 0)
  660.       fg3perc = made3 / att3;
  661.    else
  662.       fg3perc = 0;
  663.    if (attft != 0)
  664.       ftperc  = madeft / attft;
  665.    else
  666.       ftperc = 0;
  667.  
  668.    printf("------------------------------------------------------------------------------\n");
  669.  
  670.    printf("TEAM TOTALS :         ");
  671.    printf("   %2.0f",made2);
  672.    printf("   %2.0f",att2);
  673.    printf("    %2.0f",made3);
  674.    printf("   %2.0f",att3);
  675.    printf("    %2.0f",madeft);
  676.    printf("   %2.0f",attft);
  677.    printf("    %2.0f",rebs);
  678.    printf("    %2.0f",blks);
  679.    printf("    %2.0f\n",steals);
  680.  
  681.    printf("SHOOTING PERCENTAGES :");
  682.    printf("   %3.1f",(fg2perc * 100));
  683.    printf("        %3.1f",(fg3perc * 100));
  684.    printf("        %3.1f\n",(ftperc * 100));
  685. }
  686.  
  687. /*****************
  688.  *   jump ball   *
  689.  *****************/
  690.  
  691. TEAM_PTR jump_ball(a,b)
  692.  
  693. TEAM_PTR a,b;
  694.  
  695. {
  696.    int a_ball = 0, b_ball = 0;
  697.    PLAYER_PTR a_pl, b_pl;
  698.    TEAM_PTR got_it = NULL;
  699.  
  700.    a_pl = a->pl[4];
  701.    b_pl = b->pl[4];
  702.    while (a_ball == b_ball) {
  703.       a_ball = random(0,(a_pl->perc_reb));
  704.       b_ball = random(0,(b_pl->perc_reb));
  705.       }
  706.  
  707.    if (a_ball > b_ball)
  708.       got_it = a;
  709.    else
  710.       got_it = b;
  711.    printf("\nThe %s win the TIP...\n",got_it->team_name);
  712.    ball = random(0,3);      /*   randomize person who got the ball   */
  713.  
  714.    return(got_it);
  715. }
  716.  
  717. /*******************************
  718.  *   determine player action   *
  719.  *******************************/
  720.  
  721. int action(tp)
  722.  
  723. TEAM_PTR tp;
  724.  
  725. {
  726.    int r = 0, value = 0;
  727.    PLAYER_PTR p;
  728.  
  729.    p = tp->pl[ball];
  730.    if (back_court) {
  731.       back_court = FALSE;
  732.       r = random(0,100);
  733.       if (r <= (2 * p->perc_drive))
  734.          value = DRIVE;
  735.       else
  736.          value = PASS;
  737.       }
  738.    else {
  739.       r = random(0,100);
  740.       if (r <= (p->perc_drive))
  741.          value = DRIVE;
  742.       else if (r <= (p->perc_drive + p->perc_shoot))
  743.          value = SHOOT;
  744.       else
  745.          value = PASS;
  746.       }
  747.  
  748.    return(value);      
  749. }
  750.  
  751. /*****************************
  752.  *   process player action   *
  753.  *****************************/
  754.  
  755. TEAM_PTR proc_action(tp,dtp,act)
  756.  
  757. int act;
  758. TEAM_PTR tp, dtp;
  759.  
  760. {
  761.    int result, r1, val;
  762.    PLAYER_PTR op, dp;
  763.    TEAM_PTR ret_ptr = NULL;
  764.  
  765.    op = tp->pl[ball];           /*   offensive player   */
  766.    dp = dtp->pl[ball];          /*   defensive player   */
  767.    switch (act) {
  768.       case DRIVE :
  769.          printf("%s dribbles the ball...\n",op->name);
  770.          pause();
  771.          printf("He spots an opening, drives...\n");
  772.          pause();
  773.          result = proc_drive(tp,dtp);
  774.          break;
  775.       case PASS :
  776.          printf("%s passes the ball to ",op->name);
  777.          pause();
  778.          result = proc_pass(tp,dtp);
  779.          break;
  780.       case SHOOT :
  781.          printf("%s puts up a ",op->name);
  782.          r1 = random(0,5);
  783.          switch (r1) {
  784.             case 0 :
  785.                printf("hook shot...\n");
  786.                break;
  787.             case 1 :
  788.                printf("long jump shot...\n");
  789.                break;
  790.             case 2 :
  791.                printf("short jump shot...\n");
  792.                break;
  793.             case 3 :
  794.                printf("fall away jumper...\n");
  795.                break;
  796.             case 4 :
  797.                printf("turn around jumper...\n");
  798.                break;
  799.             case 5 :
  800.                printf("pull up jumper...\n");
  801.                break;
  802.             }
  803.          pause();
  804.          result = proc_shot(tp,dtp);
  805.          break;
  806.       }  /*   end of action   */
  807.  
  808.    switch (result) {
  809.       case DEF_FOUL :
  810.          if (shooting)
  811.             val = 2;
  812.          else if (dtp->foul >= 7)
  813.             val = 1;
  814.          else {
  815.             val = 0;
  816.             ret_ptr = tp;
  817.             if (dtp->foul == 6) {
  818.                printf("*** The next foul will put the %s into the bonus...\n",ret_ptr->team_name);
  819.                pause();
  820.                }
  821.             }
  822.          if (val != 0) {
  823.             if ((result = free_throw(tp,dtp,val)) == NO_CHANGE)
  824.                ret_ptr = tp;
  825.             else {
  826.                ret_ptr = dtp;
  827.                op = ret_ptr->pl[ball];
  828.                if (result == TURNOVER)
  829.                   printf("%s dribbles the ball and brings it up court...\n",op->name);
  830.                }
  831.             }
  832.          break;
  833.       case FG2 :
  834.          tp->score += 2;
  835.          ret_ptr = dtp;
  836.          break;
  837.       case FG3 :
  838.          tp->score += 3;
  839.          ret_ptr = dtp;
  840.          break;
  841.       case TURNOVER :
  842.          printf("Turnover !!!, %s ball...\n",dtp->team_name);
  843.          pause();
  844.          ball = 0;              /*   player 0 is the point guard   */
  845.          ret_ptr = dtp;
  846.          op = ret_ptr->pl[ball];
  847.          printf("%s brings the ball up court...\n",op->name);
  848.          back_court = TRUE;
  849.          break;
  850.       case NO_CHANGE :
  851.          ret_ptr = tp;
  852.          break;
  853.       }
  854.    pause();
  855.  
  856.    if ((result != TURNOVER) && (result != NO_CHANGE)) {
  857.       printf("\n*** %s %d   %s %d   Time left : %4.2f\n",team_a->team_name,team_a->score,team_b->team_name,team_b->score,time);
  858.       pause();
  859.       ball = 0;
  860.       op = ret_ptr->pl[ball];
  861.       printf("The inbound pass goes to %s...and he brings the ball up the court...\n",op->name);
  862.       back_court = TRUE;
  863.       pause();
  864.       }
  865.  
  866.    return(ret_ptr);
  867. }
  868.  
  869. /*********************
  870.  *   process drive   *
  871.  *********************/
  872.  
  873. int proc_drive(tp,dtp)
  874.  
  875. TEAM_PTR tp, dtp;
  876.  
  877. {
  878.    int r1,r2;
  879.    int ret_val = 99;
  880.    PLAYER_PTR op, dp;
  881.  
  882.    op = tp->pl[ball];
  883.    dp = dtp->pl[ball];
  884.    r1 = random(0,100);
  885.    r2 = random(0,100);
  886.    if ((r1 > op->perc_steal) && (r2 <= (dp->perc_steal / 5))) {
  887.       printf("The ball is stolen by %s !!!\n",dp->name);
  888.       (dp->num_steal)++;
  889.       pause();
  890.       ret_val = TURNOVER;
  891.       }
  892.    else if ((r1 <= op->perc_steal) && (r2 <= dp->perc_steal)) {
  893.       printf("FOUL - Reaching in, #%2d of the %s\n",dp->num,dtp->team_name);
  894.       pause();
  895.       (dtp->foul)++;
  896.       ret_val = DEF_FOUL;
  897.       }
  898.    else {
  899.       dp = dtp->pl[4];             /*   blocked by center ?   */
  900.       r1 = random(0,100);
  901.       r2 = random(0,100);
  902.       (op->fg2_att)++;
  903.       if ((r1 > op->perc_blk) && (r2 <= dp->perc_blk)) {
  904.          printf("Its blocked by %s !!!\n",dp->name);
  905.          (dp->num_blk)++;
  906.          pause();
  907.          r2 = random(0,100);
  908.          ball = random(0,4);
  909.          if (r2 > 50) {
  910.             ret_val = TURNOVER;
  911.             op = dtp->pl[ball];
  912.             }
  913.          else {
  914.             ret_val = NO_CHANGE;
  915.             op = tp->pl[ball];
  916.             }
  917.          printf("Loose ball picked up by %s...\n",op->name);
  918.          }
  919.       else if ((r1 <= op->perc_blk) && (r2 <= dp->perc_blk)) {   /*   foul ?   */
  920.          if (op->perc_steal > dp->perc_steal) {
  921.             printf("FOUL - Hacking, #%2d of the %s\n",dp->num,dtp->team_name);
  922.             pause();
  923.             (dtp->foul)++;
  924.             shooting = TRUE;
  925.             ret_val = DEF_FOUL;
  926.             }
  927.          else if (op->perc_steal < dp->perc_steal) {
  928.             printf("OFFENSIVE FOUL - Charging, #%2d of the %s\n",op->num,tp->team_name);
  929.             pause();
  930.             (tp->foul)++;
  931.             ret_val = TURNOVER;
  932.             }
  933.          else {
  934.             printf("FOUL - Blocking, #%2d of the %s\n",dp->num,dtp->team_name);
  935.             pause();
  936.             (dtp->foul)++;
  937.             shooting = TRUE;
  938.             ret_val = DEF_FOUL;
  939.             }
  940.          }
  941.       else {                       /*   else shot is up...   */
  942.          r1 = random(0,100);
  943.          if (r1 > 25) {            /*   shot is a layup      */
  944.             r2 = random(0,100);
  945.             if (r2 <= ((op->perc_fg2) * 2)) {
  946.                printf("The layup is good...\n");
  947.                (op->fg2_made)++;
  948.                ret_val = FG2;
  949.                }
  950.             else {
  951.                printf("He blows the easy layup !!!\n");
  952.                pause();
  953.                ret_val = chk_reb(tp,dtp);
  954.                }
  955.             }
  956.          else {                    /*   shot is a slam       */
  957.             r1 = random(0,100);
  958.             if (r1 <= ((op->perc_fg2) * 2)) {      /*   slam is good   */
  959.                r2 = random(0,5);
  960.                switch (r2) {
  961.                   case 0 :
  962.                      printf("A reverse ");
  963.                      break;
  964.                   case 1 :
  965.                      printf("A double pump ");
  966.                      break;
  967.                   case 2 :
  968.                      printf("A spinning reverse ");
  969.                      break;
  970.                   case 3 :
  971.                      printf("A two handed ");
  972.                      break;
  973.                   case 4 :
  974.                      printf("A one handed ");
  975.                      break;
  976.                   case 5 :
  977.                      printf("A ");
  978.                      break;
  979.                   }
  980.                printf("Slam Dunk !!!\n");
  981.                if (r2 <= 2)
  982.                   printf("*** The crowd ROARS !!!\n");
  983.                (op->fg2_made)++;
  984.                ret_val = FG2;
  985.                }
  986.             else {
  987.                printf("He blows the easy Slam !!!\n");
  988.                ret_val = chk_reb(tp,dtp);
  989.                }          /*   endif slam         */
  990.             }             /*   endif layup/slam ? */
  991.          pause();
  992.          }                /*   endif shot is up   */
  993.       }                   /*   endif blocked ?    */
  994.    return(ret_val);
  995. }
  996.  
  997. /********************
  998.  *   process pass   *
  999.  ********************/
  1000.  
  1001. int proc_pass(tp,dtp)
  1002.  
  1003. TEAM_PTR tp, dtp;
  1004.  
  1005. {
  1006.    int r1 = 0, r2 = 0, r;
  1007.    int ret_val = 0;
  1008.    PLAYER_PTR pp, dpp;
  1009.  
  1010.    pp = tp->pl[ball];
  1011.    dpp = dtp->pl[ball];
  1012.    r1 = random(0,100);
  1013.    r2 = random(0,100);
  1014.    pause();
  1015.    if ((r1 > pp->perc_steal) && (r2 <= (dpp->perc_steal / 5))) {
  1016.       printf("...Wait !!!   the pass is stolen by %s !!!\n",dpp->name);
  1017.       (dpp->num_steal)++;
  1018.       ret_val = TURNOVER;
  1019.       }
  1020.    else {
  1021.       r1 = random(0,100);
  1022.       if ((r1 <= (pp->perc_fg3 / 5)) && ((ball == 0) || (ball == 1))) {
  1023.          ball = random(2,4);
  1024.          pp = tp->pl[ball];
  1025.          dpp = dtp->pl[ball];
  1026.          printf("...Wait !!!   Its a back door play to %s\n",pp->name);
  1027.          pause();
  1028.          r2 = random(0,100);
  1029.          (pp->fg2_att)++;
  1030.          if (r2 <= (pp->perc_reb * 3)){
  1031.             printf("Alley Oop !!!   2 points\n");
  1032.             pause();
  1033.             printf("*** The crowd is cheers !!!\n");
  1034.             pause();
  1035.             (pp->fg2_made)++;
  1036.             ret_val = FG2;
  1037.             }
  1038.          else {
  1039.             r1 = random(0,100);
  1040.             if (r1 < 50)
  1041.                printf("Awww...He couldn't get the pass, its off the backboard...\n");
  1042.             else
  1043.                printf("Awww...Good defense by %s...\n",dpp->name);
  1044.             ret_val = chk_reb(tp,dtp);
  1045.             }
  1046.          }
  1047.       else {
  1048.          ret_val = NO_CHANGE;
  1049.          r = ball;
  1050.          while (r == ball)           /*   pass ball to another player   */
  1051.             r = random(0,4);
  1052.          ball = r;
  1053.          pp = tp->pl[ball];
  1054.          printf("%s\n",pp->name);
  1055.          }
  1056.       }
  1057.    pause();
  1058.  
  1059.    return(ret_val);
  1060. }
  1061.  
  1062. /********************
  1063.  *   process shot   *
  1064.  ********************/
  1065.  
  1066. int proc_shot(tp,dtp)
  1067.  
  1068. TEAM_PTR tp, dtp;
  1069.  
  1070. {
  1071.    int r1, r2, r;
  1072.    int ret_val;
  1073.    PLAYER_PTR op,dp;
  1074.  
  1075.    r1 = random(0,100);
  1076.    r2 = random(0,100);
  1077.    op = tp->pl[ball];
  1078.    dp = dtp->pl[ball];
  1079.    if ((r1 > op->perc_blk) && (r2 <= dp->perc_blk)) {
  1080.       printf("Its blocked by %s !!!\n",dp->name);
  1081.       (dp->num_blk)++;
  1082.       pause();
  1083.       r2 = random(0,100);
  1084.       if (r2 > op->perc_fg3)                    /*   record shot attempt   */
  1085.          (op->fg2_att)++;
  1086.       else
  1087.          (op->fg3_att)++;
  1088.       r2 = random(0,100);
  1089.       ball = random(0,4);
  1090.       if (r2 > 50) {
  1091.          ret_val = TURNOVER;
  1092.          op = dtp->pl[ball];
  1093.          }
  1094.       else {
  1095.          ret_val = NO_CHANGE;
  1096.          op = tp->pl[ball];
  1097.          }
  1098.       printf("Loose ball picked up by %s...\n",op->name);
  1099.       }
  1100.    else if ((r1 <= op->perc_blk) && (r2 <= dp->perc_blk)) {   /*   foul   */
  1101.       printf("FOUL - Hacking, #%2d of the %s\n",dp->num,dtp->team_name);
  1102.       pause();
  1103.       (dtp->foul)++;
  1104.       shooting = TRUE;
  1105.       ret_val = DEF_FOUL;
  1106.       }
  1107.    else {                         /*   else shot is up   */
  1108.       (op->fg2_att)++;
  1109.       r2 = random(0,100);
  1110.       if (r2 > op->perc_fg3) {              /*   2 point shot      */
  1111.          ret_val = FG2;
  1112.          printf("Its a 2 pointer...and ");
  1113.          pause();
  1114.          r2 = random(0,100);
  1115.          if (r2 <= op->perc_fg2) {
  1116.             printf("its good !!!\n");
  1117.             (op->fg2_made)++;
  1118.             }
  1119.          else
  1120.             ret_val = TURNOVER;
  1121.          }
  1122.       else {                             /*   3 point shot   */
  1123.          (op->fg3_att)++;
  1124.          ret_val = FG3;
  1125.          printf("Its a 3 pointer...and ");
  1126.          pause();
  1127.          r2 = random(0,100);
  1128.          if (r2 <= op->perc_fg3) {
  1129.             printf("its good !!!\n");
  1130.             (op->fg3_made)++;
  1131.             }
  1132.          else
  1133.             ret_val = TURNOVER;
  1134.          }
  1135.       pause();
  1136.  
  1137.       if ((abs((tp->score) - (dtp->score)) < 3) && (ret_val != TURNOVER)) {
  1138.          printf("*** The crowd is going wild !!!\n");
  1139.          pause();                            /*   if close game   */
  1140.          }
  1141.  
  1142.       if (ret_val == TURNOVER) {
  1143.          r2 = random(0,3);
  1144.          switch (r2) {
  1145.             case 0 :
  1146.                printf("its an airball !!!\n");
  1147.                break;
  1148.             case 1 :
  1149.                printf("its off the rim !!!\n");
  1150.                break;
  1151.             case 2 :
  1152.                printf("its off the backboard !!!\n");
  1153.                break;
  1154.             case 3 :
  1155.                printf("its a brick !!!\n");
  1156.                break;
  1157.             }
  1158.          pause();
  1159.          ret_val = chk_reb(tp,dtp);       /*   check who rebounds   */
  1160.          }                   /*   endif turnover       */
  1161.       }                      /*   endif shot           */
  1162.    pause();
  1163.  
  1164.    return(ret_val);
  1165. }
  1166.  
  1167. /*********************
  1168.  *   check rebound   *
  1169.  *********************/
  1170.  
  1171. int chk_reb(tp,dtp)
  1172.  
  1173. TEAM_PTR tp,dtp;
  1174.  
  1175. {
  1176.    int i, ret_val;
  1177.    int r1,r2;
  1178.    PLAYER_PTR op,dp;
  1179.  
  1180.    i = 4;
  1181.    ret_val = 99;
  1182.    printf("The rebound is...");
  1183.    while ((i >= 0) && (ret_val != NO_CHANGE) && (ret_val != TURNOVER)) {
  1184.       r1 = random(0,100);
  1185.       r2 = random(0,100);
  1186.       op = tp->pl[i];
  1187.       dp = dtp->pl[i];
  1188.       if (((r1 <= op->perc_reb) && (r2 <= dp->perc_reb)) || ((r1 > op->perc_reb) && (r2 > dp->perc_reb)))
  1189.          printf("tipped by %s and %s...\n",op->name,dp->name);
  1190.       else if ((r1 <= op->perc_reb) && (r2 > dp->perc_reb)) {
  1191.          printf("grabbed by %s of the %s...\n",op->name,tp->team_name);
  1192.          (op->num_reb)++;
  1193.          ret_val = NO_CHANGE;
  1194.          ball = i;
  1195.          }
  1196.       else if ((r1 > op->perc_reb) && (r2 <= dp->perc_reb)) {
  1197.          printf("grabbed by %s of the %s...\n",dp->name,dtp->team_name);
  1198.          (dp->num_reb)++;
  1199.          ret_val = TURNOVER;
  1200.          ball = i;
  1201.          }
  1202.       pause();
  1203.       --i;
  1204.       }
  1205.  
  1206.    if ((ret_val != TURNOVER) && (ret_val != NO_CHANGE)) {
  1207.       printf("Out of bounds...");
  1208.       pause();
  1209.       r1 = random(0,100);
  1210.       r2 = random(0,4);
  1211.       if (r1 > 50) {
  1212.          printf("Last touched by %s of the %s...\n",op->name,tp->team_name);
  1213.          ret_val = TURNOVER;
  1214.          }
  1215.       else {
  1216.          printf("Last touched by %s of the %s...\n",dp->name,dtp->team_name);
  1217.          ret_val = NO_CHANGE;
  1218.          }
  1219.       pause();
  1220.       }
  1221.    return(ret_val);
  1222. }
  1223.  
  1224. /******************
  1225.  *   free throw   *
  1226.  ******************/
  1227.  
  1228. free_throw(tp,dtp,n)
  1229.  
  1230. TEAM_PTR tp, dtp;
  1231. int n;
  1232.  
  1233. {
  1234.    int r1, r2, i;
  1235.    int another = TRUE, ret_val;
  1236.    PLAYER_PTR op;
  1237.  
  1238.    printf("*** Free throws...");
  1239.    pause();
  1240.    if (n == 1)
  1241.       printf("one and one\n");
  1242.    else
  1243.       printf("two shots\n");
  1244.    pause();
  1245.    op = tp->pl[ball];
  1246.    printf("%s steps up to the line...\n",op->name);
  1247.    pause();
  1248.  
  1249.    i = 0;
  1250.    while (another) {
  1251.       if (i == 0)
  1252.          printf("   The first one is up...");
  1253.       else
  1254.          printf("   The second one is up...");
  1255.       pause();
  1256.       (op->ft_att)++;
  1257.       r1 = random(0,100);
  1258.       if (r1 <= op->perc_ft) {
  1259.          printf("its good...\n");
  1260.          pause();
  1261.          (tp->score)++;
  1262.          (op->ft_made)++;
  1263.          another = TRUE;
  1264.          ret_val = DEF_FOUL;
  1265.          }
  1266.       else {
  1267.          printf("its off the rim !!!\n");
  1268.          if ((n == 2) && (i == 0))
  1269.             another = TRUE;
  1270.          else if ((n == 2) && (i == 1)) {
  1271.             another = FALSE;
  1272.             ret_val = chk_reb(tp,dtp);
  1273.             }
  1274.          else if (n == 1) {
  1275.             another = FALSE;
  1276.             ret_val = chk_reb(tp,dtp);
  1277.             }
  1278.          }
  1279.       pause();
  1280.       ++i;
  1281.       if (i == 2)
  1282.          another = FALSE;
  1283.       }
  1284.  
  1285.    return(ret_val);
  1286. }
  1287.  
  1288. /******************
  1289.  *   randomizer   *
  1290.  ******************/
  1291.  
  1292. int random(a,b)        /*   return an integer random number between a & b   */
  1293.  
  1294. int a,b;
  1295.  
  1296. {
  1297.    double r = 0;
  1298.    int value = 0;
  1299.  
  1300.    r = ((double) rand()) / pow((double) 2, (double) 15);
  1301.    value = (a + (int) (((b - a) * r) + .5));
  1302.  
  1303.    return(value);
  1304. }
  1305.  
  1306. /*************
  1307.  *   pause   *
  1308.  *************/
  1309.  
  1310. pause()         /*   pause for DELAY-loops   */
  1311.  
  1312. {
  1313.    int i;
  1314.  
  1315.    for (i = 0;i < delay; i++)
  1316.       ;
  1317. }
  1318.  
  1319. /**********************
  1320.  *   end of program   *
  1321.  **********************/
  1322.